/*! AutoFill 1.2.1
 * ©2008-2014 SpryMedia Ltd - datatables.net/license
 */

/**
 * @summary     AutoFill
 * @description Add Excel like click and drag auto-fill options to DataTables
 * @version     1.2.1
 * @file        dataTables.autoFill.js
 * @author      SpryMedia Ltd (www.sprymedia.co.uk)
 * @contact     www.sprymedia.co.uk/contact
 * @copyright   Copyright 2010-2014 SpryMedia Ltd.
 *
 * This source file is free software, available under the following license:
 *   MIT license - http://datatables.net/license/mit
 *
 * This source file is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE. See the license files for details.
 *
 * For details please refer to: http://www.datatables.net
 */

(function (window, document, undefined) {

    var factory = function ($, DataTable) {
        "use strict";

        /** 
         * AutoFill provides Excel like auto-fill features for a DataTable
         *
         * @class AutoFill
         * @constructor
         * @param {object} oTD DataTables settings object
         * @param {object} oConfig Configuration object for AutoFill
         */
        var AutoFill = function (oDT, oConfig)
        {
            /* Sanity check that we are a new instance */
            if (!(this instanceof AutoFill)) {
                throw("Warning: AutoFill must be initialised with the keyword 'new'");
            }

            if (!$.fn.dataTableExt.fnVersionCheck('1.7.0')) {
                throw("Warning: AutoFill requires DataTables 1.7 or greater");
            }


            /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
             * Public class variables
             * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

            this.c = {};

            /**
             * @namespace Settings object which contains customisable information for AutoFill instance
             */
            this.s = {
                /**
                 * @namespace Cached information about the little dragging icon (the filler)
                 */
                "filler": {
                    "height": 0,
                    "width": 0
                },

                /**
                 * @namespace Cached information about the border display
                 */
                "border": {
                    "width": 2
                },

                /**
                 * @namespace Store for live information for the current drag
                 */
                "drag": {
                    "startX": -1,
                    "startY": -1,
                    "startTd": null,
                    "endTd": null,
                    "dragging": false
                },

                /**
                 * @namespace Data cache for information that we need for scrolling the screen when we near
                 *   the edges
                 */
                "screen": {
                    "interval": null,
                    "y": 0,
                    "height": 0,
                    "scrollTop": 0
                },

                /**
                 * @namespace Data cache for the position of the DataTables scrolling element (when scrolling
                 *   is enabled)
                 */
                "scroller": {
                    "top": 0,
                    "bottom": 0
                },

                /**
                 * @namespace Information stored for each column. An array of objects
                 */
                "columns": []
            };


            /**
             * @namespace Common and useful DOM elements for the class instance
             */
            this.dom = {
                "table": null,
                "filler": null,
                "borderTop": null,
                "borderRight": null,
                "borderBottom": null,
                "borderLeft": null,
                "currentTarget": null
            };



            /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
             * Public class methods
             * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

            /**
             * Retreieve the settings object from an instance
             *  @method fnSettings
             *  @returns {object} AutoFill settings object
             */
            this.fnSettings = function () {
                return this.s;
            };


            /* Constructor logic */
            this._fnInit(oDT, oConfig);
            return this;
        };



        AutoFill.prototype = {
            /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
             * Private methods (they are of course public in JS, but recommended as private)
             * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

            /**
             * Initialisation
             *  @method _fnInit
             *  @param {object} dt DataTables settings object
             *  @param {object} config Configuration object for AutoFill
             *  @returns void
             */
            "_fnInit": function (dt, config)
            {
                var
                        that = this,
                        i, iLen;

                // Use DataTables API to get the settings allowing selectors, instances
                // etc to be used, or for backwards compatibility get from the old
                // fnSettings method
                this.s.dt = DataTable.Api ?
                        new DataTable.Api(dt).settings()[0] :
                        dt.fnSettings();
                this.s.init = config || {};
                this.dom.table = this.s.dt.nTable;

                $.extend(true, this.c, AutoFill.defaults, config);

                /* Add and configure the columns */
                this._initColumns();

                /* Auto Fill click and drag icon */
                var filler = $('<div/>', {
                    'class': 'AutoFill_filler'
                })
                        .appendTo('body');
                this.dom.filler = filler[0];

                // Get the height / width of the click element
                this.s.filler.height = filler.height();
                this.s.filler.width = filler.width();
                filler[0].style.display = "none";

                /* Border display - one div for each side. We can't just use a single
                 * one with a border, as we want the events to effectively pass through
                 * the transparent bit of the box
                 */
                var border;
                var appender = document.body;
                if (that.s.dt.oScroll.sY !== "") {
                    that.s.dt.nTable.parentNode.style.position = "relative";
                    appender = that.s.dt.nTable.parentNode;
                }

                border = $('<div/>', {
                    "class": "AutoFill_border"
                });
                this.dom.borderTop = border.clone().appendTo(appender)[0];
                this.dom.borderRight = border.clone().appendTo(appender)[0];
                this.dom.borderBottom = border.clone().appendTo(appender)[0];
                this.dom.borderLeft = border.clone().appendTo(appender)[0];

                /* Events */
                filler.on('mousedown.DTAF', function (e) {
                    this.onselectstart = function () {
                        return false;
                    };
                    that._fnFillerDragStart.call(that, e);
                    return false;
                });

                $('tbody', this.dom.table).on(
                        'mouseover.DTAF mouseout.DTAF',
                        '>tr>td, >tr>th',
                        function (e) {
                            that._fnFillerDisplay.call(that, e);
                        }
                );

                $(this.dom.table).on('destroy.dt.DTAF', function () {
                    filler.off('mousedown.DTAF').remove();
                    $('tbody', this.dom.table).off('mouseover.DTAF mouseout.DTAF');
                });
            },

            _initColumns: function ( )
            {
                var that = this;
                var i, ien;
                var dt = this.s.dt;
                var config = this.s.init;

                for (i = 0, ien = dt.aoColumns.length; i < ien; i++) {
                    this.s.columns[i] = $.extend(true, {}, AutoFill.defaults.column);
                }

                dt.oApi._fnApplyColumnDefs(
                        dt,
                        config.aoColumnDefs || config.columnDefs,
                        config.aoColumns || config.columns,
                        function (colIdx, def) {
                            that._fnColumnOptions(colIdx, def);
                        }
                );

                // For columns which don't have read, write, step functions defined,
                // use the default ones
                for (i = 0, ien = dt.aoColumns.length; i < ien; i++) {
                    var column = this.s.columns[i];

                    if (!column.read) {
                        column.read = this._fnReadCell;
                    }
                    if (!column.write) {
                        column.read = this._fnWriteCell;
                    }
                    if (!column.step) {
                        column.read = this._fnStep;
                    }
                }
            },

            "_fnColumnOptions": function (i, opts)
            {
                var column = this.s.columns[ i ];
                var set = function (outProp, inProp) {
                    if (opts[ inProp[0] ] !== undefined) {
                        column[ outProp ] = opts[ inProp[0] ];
                    }
                    if (opts[ inProp[1] ] !== undefined) {
                        column[ outProp ] = opts[ inProp[1] ];
                    }
                };

                // Compatibility with the old Hungarian style of notation
                set('enable', ['bEnable', 'enable']);
                set('read', ['fnRead', 'read']);
                set('write', ['fnWrite', 'write']);
                set('step', ['fnStep', 'step']);
                set('increment', ['bIncrement', 'increment']);
            },

            /**
             * Find out the coordinates of a given TD cell in a table
             *  @method  _fnTargetCoords
             *  @param   {Node} nTd
             *  @returns {Object} x and y properties, for the position of the cell in the tables DOM
             */
            "_fnTargetCoords": function (nTd)
            {
                var nTr = $(nTd).parents('tr')[0];
                var position = this.s.dt.oInstance.fnGetPosition(nTd);

                return {
                    "x": $('td', nTr).index(nTd),
                    "y": $('tr', nTr.parentNode).index(nTr),
                    "row": position[0],
                    "column": position[2]
                };
            },

            /**
             * Display the border around one or more cells (from start to end)
             *  @method  _fnUpdateBorder
             *  @param   {Node} nStart Starting cell
             *  @param   {Node} nEnd Ending cell
             *  @returns void
             */
            "_fnUpdateBorder": function (nStart, nEnd)
            {
                var
                        border = this.s.border.width,
                        offsetStart = $(nStart).offset(),
                        offsetEnd = $(nEnd).offset(),
                        x1 = offsetStart.left - border,
                        x2 = offsetEnd.left + $(nEnd).outerWidth(),
                        y1 = offsetStart.top - border,
                        y2 = offsetEnd.top + $(nEnd).outerHeight(),
                        width = offsetEnd.left + $(nEnd).outerWidth() - offsetStart.left + (2 * border),
                        height = offsetEnd.top + $(nEnd).outerHeight() - offsetStart.top + (2 * border),
                        oStyle;

                // Recalculate start and end (when dragging "backwards")  
                if (offsetStart.left > offsetEnd.left) {
                    x1 = offsetEnd.left - border;
                    x2 = offsetStart.left + $(nStart).outerWidth();
                    width = offsetStart.left + $(nStart).outerWidth() - offsetEnd.left + (2 * border);
                }

                if (this.s.dt.oScroll.sY !== "")
                {
                    /* The border elements are inside the DT scroller - so position relative to that */
                    var
                            offsetScroll = $(this.s.dt.nTable.parentNode).offset(),
                            scrollTop = $(this.s.dt.nTable.parentNode).scrollTop(),
                            scrollLeft = $(this.s.dt.nTable.parentNode).scrollLeft();

                    x1 -= offsetScroll.left - scrollLeft;
                    x2 -= offsetScroll.left - scrollLeft;
                    y1 -= offsetScroll.top - scrollTop;
                    y2 -= offsetScroll.top - scrollTop;
                }

                /* Top */
                oStyle = this.dom.borderTop.style;
                oStyle.top = y1 + "px";
                oStyle.left = x1 + "px";
                oStyle.height = this.s.border.width + "px";
                oStyle.width = width + "px";

                /* Bottom */
                oStyle = this.dom.borderBottom.style;
                oStyle.top = y2 + "px";
                oStyle.left = x1 + "px";
                oStyle.height = this.s.border.width + "px";
                oStyle.width = width + "px";

                /* Left */
                oStyle = this.dom.borderLeft.style;
                oStyle.top = y1 + "px";
                oStyle.left = x1 + "px";
                oStyle.height = height + "px";
                oStyle.width = this.s.border.width + "px";

                /* Right */
                oStyle = this.dom.borderRight.style;
                oStyle.top = y1 + "px";
                oStyle.left = x2 + "px";
                oStyle.height = height + "px";
                oStyle.width = this.s.border.width + "px";
            },

            /**
             * Mouse down event handler for starting a drag
             *  @method  _fnFillerDragStart
             *  @param   {Object} e Event object
             *  @returns void
             */
            "_fnFillerDragStart": function (e)
            {
                var that = this;
                var startingTd = this.dom.currentTarget;

                this.s.drag.dragging = true;

                that.dom.borderTop.style.display = "block";
                that.dom.borderRight.style.display = "block";
                that.dom.borderBottom.style.display = "block";
                that.dom.borderLeft.style.display = "block";

                var coords = this._fnTargetCoords(startingTd);
                this.s.drag.startX = coords.x;
                this.s.drag.startY = coords.y;

                this.s.drag.startTd = startingTd;
                this.s.drag.endTd = startingTd;

                this._fnUpdateBorder(startingTd, startingTd);

                $(document).bind('mousemove.AutoFill', function (e) {
                    that._fnFillerDragMove.call(that, e);
                });

                $(document).bind('mouseup.AutoFill', function (e) {
                    that._fnFillerFinish.call(that, e);
                });

                /* Scrolling information cache */
                this.s.screen.y = e.pageY;
                this.s.screen.height = $(window).height();
                this.s.screen.scrollTop = $(document).scrollTop();

                if (this.s.dt.oScroll.sY !== "")
                {
                    this.s.scroller.top = $(this.s.dt.nTable.parentNode).offset().top;
                    this.s.scroller.bottom = this.s.scroller.top + $(this.s.dt.nTable.parentNode).height();
                }

                /* Scrolling handler - we set an interval (which is cancelled on mouse up) which will fire
                 * regularly and see if we need to do any scrolling
                 */
                this.s.screen.interval = setInterval(function () {
                    var iScrollTop = $(document).scrollTop();
                    var iScrollDelta = iScrollTop - that.s.screen.scrollTop;
                    that.s.screen.y += iScrollDelta;

                    if (that.s.screen.height - that.s.screen.y + iScrollTop < 50)
                    {
                        $('html, body').animate({
                            "scrollTop": iScrollTop + 50
                        }, 240, 'linear');
                    } else if (that.s.screen.y - iScrollTop < 50)
                    {
                        $('html, body').animate({
                            "scrollTop": iScrollTop - 50
                        }, 240, 'linear');
                    }

                    if (that.s.dt.oScroll.sY !== "")
                    {
                        if (that.s.screen.y > that.s.scroller.bottom - 50)
                        {
                            $(that.s.dt.nTable.parentNode).animate({
                                "scrollTop": $(that.s.dt.nTable.parentNode).scrollTop() + 50
                            }, 240, 'linear');
                        } else if (that.s.screen.y < that.s.scroller.top + 50)
                        {
                            $(that.s.dt.nTable.parentNode).animate({
                                "scrollTop": $(that.s.dt.nTable.parentNode).scrollTop() - 50
                            }, 240, 'linear');
                        }
                    }
                }, 250);
            },

            /**
             * Mouse move event handler for during a move. See if we want to update the display based on the
             * new cursor position
             *  @method  _fnFillerDragMove
             *  @param   {Object} e Event object
             *  @returns void
             */
            "_fnFillerDragMove": function (e)
            {
                if (e.target && e.target.nodeName.toUpperCase() == "TD" &&
                        e.target != this.s.drag.endTd)
                {
                    var coords = this._fnTargetCoords(e.target);

                    if (this.c.mode == "y" && coords.x != this.s.drag.startX)
                    {
                        e.target = $('tbody>tr:eq(' + coords.y + ')>td:eq(' + this.s.drag.startX + ')', this.dom.table)[0];
                    }
                    if (this.c.mode == "x" && coords.y != this.s.drag.startY)
                    {
                        e.target = $('tbody>tr:eq(' + this.s.drag.startY + ')>td:eq(' + coords.x + ')', this.dom.table)[0];
                    }

                    if (this.c.mode == "either")
                    {
                        if (coords.x != this.s.drag.startX)
                        {
                            e.target = $('tbody>tr:eq(' + this.s.drag.startY + ')>td:eq(' + coords.x + ')', this.dom.table)[0];
                        } else if (coords.y != this.s.drag.startY) {
                            e.target = $('tbody>tr:eq(' + coords.y + ')>td:eq(' + this.s.drag.startX + ')', this.dom.table)[0];
                        }
                    }

                    // update coords
                    if (this.c.mode !== "both") {
                        coords = this._fnTargetCoords(e.target);
                    }

                    var drag = this.s.drag;
                    drag.endTd = e.target;

                    if (coords.y >= this.s.drag.startY) {
                        this._fnUpdateBorder(drag.startTd, drag.endTd);
                    } else {
                        this._fnUpdateBorder(drag.endTd, drag.startTd);
                    }
                    this._fnFillerPosition(e.target);
                }

                /* Update the screen information so we can perform scrolling */
                this.s.screen.y = e.pageY;
                this.s.screen.scrollTop = $(document).scrollTop();

                if (this.s.dt.oScroll.sY !== "")
                {
                    this.s.scroller.scrollTop = $(this.s.dt.nTable.parentNode).scrollTop();
                    this.s.scroller.top = $(this.s.dt.nTable.parentNode).offset().top;
                    this.s.scroller.bottom = this.s.scroller.top + $(this.s.dt.nTable.parentNode).height();
                }
            },

            /**
             * Mouse release handler - end the drag and take action to update the cells with the needed values
             *  @method  _fnFillerFinish
             *  @param   {Object} e Event object
             *  @returns void
             */
            "_fnFillerFinish": function (e)
            {
                var that = this, i, iLen, j;

                $(document).unbind('mousemove.AutoFill mouseup.AutoFill');

                this.dom.borderTop.style.display = "none";
                this.dom.borderRight.style.display = "none";
                this.dom.borderBottom.style.display = "none";
                this.dom.borderLeft.style.display = "none";

                this.s.drag.dragging = false;

                clearInterval(this.s.screen.interval);

                var cells = [];
                var table = this.dom.table;
                var coordsStart = this._fnTargetCoords(this.s.drag.startTd);
                var coordsEnd = this._fnTargetCoords(this.s.drag.endTd);
                var columnIndex = function (visIdx) {
                    return that.s.dt.oApi._fnVisibleToColumnIndex(that.s.dt, visIdx);
                };

                // xxx - urgh - there must be a way of reducing this...
                if (coordsStart.y <= coordsEnd.y) {
                    for (i = coordsStart.y; i <= coordsEnd.y; i++) {
                        if (coordsStart.x <= coordsEnd.x) {
                            for (j = coordsStart.x; j <= coordsEnd.x; j++) {
                                cells.push({
                                    node: $('tbody>tr:eq(' + i + ')>td:eq(' + j + ')', table)[0],
                                    x: j - coordsStart.x,
                                    y: i - coordsStart.y,
                                    colIdx: columnIndex(j)
                                });
                            }
                        } else {
                            for (j = coordsStart.x; j >= coordsEnd.x; j--) {
                                cells.push({
                                    node: $('tbody>tr:eq(' + i + ')>td:eq(' + j + ')', table)[0],
                                    x: j - coordsStart.x,
                                    y: i - coordsStart.y,
                                    colIdx: columnIndex(j)
                                });
                            }
                        }
                    }
                } else {
                    for (i = coordsStart.y; i >= coordsEnd.y; i--) {
                        if (coordsStart.x <= coordsEnd.x) {
                            for (j = coordsStart.x; j <= coordsEnd.x; j++) {
                                cells.push({
                                    node: $('tbody>tr:eq(' + i + ')>td:eq(' + j + ')', table)[0],
                                    x: j - coordsStart.x,
                                    y: i - coordsStart.y,
                                    colIdx: columnIndex(j)
                                });
                            }
                        } else {
                            for (j = coordsStart.x; j >= coordsEnd.x; j--) {
                                cells.push({
                                    node: $('tbody>tr:eq(' + i + ')>td:eq(' + j + ')', table)[0],
                                    x: coordsStart.x - j,
                                    y: coordsStart.y - i,
                                    colIdx: columnIndex(j)
                                });
                            }
                        }
                    }
                }

                // An auto-fill requires 2 or more cells
                if (cells.length <= 1) {
                    return;
                }

                var edited = [];
                var previous;

                for (i = 0, iLen = cells.length; i < iLen; i++) {
                    var cell = cells[i];
                    var column = this.s.columns[ cell.colIdx ];
                    var read = column.read.call(column, cell.node);
                    var stepValue = column.step.call(column, cell.node, read, previous, i, cell.x, cell.y);

                    column.write.call(column, cell.node, stepValue);

                    previous = stepValue;
                    edited.push({
                        cell: cell,
                        colIdx: cell.colIdx,
                        newValue: stepValue,
                        oldValue: read
                    });
                }

                if (this.c.complete !== null) {
                    this.c.complete.call(this, edited);
                }

                // In 1.10 we can do a static draw
                if (DataTable.Api) {
                    new DataTable.Api(this.s.dt).draw(false);
                } else {
                    this.s.dt.oInstance.fnDraw();
                }
            },

            /**
             * Display the drag handle on mouse over cell
             *  @method  _fnFillerDisplay
             *  @param   {Object} e Event object
             *  @returns void
             */
            "_fnFillerDisplay": function (e)
            {
                var filler = this.dom.filler;

                /* Don't display automatically when dragging */
                if (this.s.drag.dragging)
                {
                    return;
                }

                /* Check that we are allowed to AutoFill this column or not */
                var nTd = (e.target.nodeName.toLowerCase() == 'td') ? e.target : $(e.target).parents('td')[0];
                var iX = this._fnTargetCoords(nTd).column;
                if (!this.s.columns[iX].enable)
                {
                    filler.style.display = "none";
                    return;
                }

                if (e.type == 'mouseover')
                {
                    this.dom.currentTarget = nTd;
                    this._fnFillerPosition(nTd);

                    filler.style.display = "block";
                } else if (!e.relatedTarget || !e.relatedTarget.className.match(/AutoFill/))
                {
                    filler.style.display = "none";
                }
            },

            /**
             * Position the filler icon over a cell
             *  @method  _fnFillerPosition
             *  @param   {Node} nTd Cell to position filler icon over
             *  @returns void
             */
            "_fnFillerPosition": function (nTd)
            {
                var offset = $(nTd).offset();
                var filler = this.dom.filler;
                filler.style.top = (offset.top - (this.s.filler.height / 2) - 1 + $(nTd).outerHeight()) + "px";
                filler.style.left = (offset.left - (this.s.filler.width / 2) - 1 + $(nTd).outerWidth()) + "px";
            }
        };


// Alias for access
        DataTable.AutoFill = AutoFill;
        DataTable.AutoFill = AutoFill;



        /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
         * Constants
         * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

        /**
         * AutoFill version
         *  @constant  version
         *  @type      String
         *  @default   See code
         */
        AutoFill.version = "1.2.1";


        /**
         * AutoFill defaults
         *  @namespace
         */
        AutoFill.defaults = {
            /**
             * Mode for dragging (restrict to y-axis only, x-axis only, either one or none):
             *
             *  * `y`      - y-axis only (default)
             *  * `x`      - x-axis only
             *  * `either` - either one, but not both axis at the same time
             *  * `both`   - multiple cells allowed
             *
             * @type {string}
             * @default `y`
             */
            mode: 'y',

            complete: null,

            /**
             * Column definition defaults
             *  @namespace
             */
            column: {
                /**
                 * If AutoFill should be enabled on this column
                 *
                 * @type {boolean}
                 * @default true
                 */
                enable: true,

                /**
                 * Allow automatic increment / decrement on this column if a number
                 * is found.
                 *
                 * @type {boolean}
                 * @default true
                 */
                increment: true,

                /**
                 * Cell read function
                 *
                 * Default function will simply read the value from the HTML of the
                 * cell.
                 *
                 * @type   {function}
                 * @param  {node} cell `th` / `td` element to read the value from
                 * @return {string}    Data that has been read
                 */
                read: function (cell) {
                    return $(cell).html();
                },

                /**
                 * Cell write function
                 *
                 * Default function will simply write to the HTML and tell the DataTable
                 * to update.
                 *
                 * @type   {function}
                 * @param  {node} cell `th` / `td` element to write the value to
                 * @return {string}    Data two write
                 */
                write: function (cell, val) {
                    var table = $(cell).parents('table');
                    if (DataTable.Api) {
                        // 1.10
                        table.DataTable().cell(cell).data(val);
                    } else {
                        // 1.9
                        var dt = table.dataTable();
                        var pos = dt.fnGetPosition(cell);
                        dt.fnUpdate(val, pos[0], pos[2], false);
                    }
                },

                /**
                 * Step function. This provides the ability to customise how the values
                 * are incremented.
                 *
                 * @param  {node} cell `th` / `td` element that is being operated upon
                 * @param  {string} read Cell value from `read` function
                 * @param  {string} last Value of the previous cell
                 * @param  {integer} i Loop counter
                 * @param  {integer} x Cell x-position in the current auto-fill. The
                 *   starting cell is coordinate 0 regardless of its physical position
                 *   in the DataTable.
                 * @param  {integer} y Cell y-position in the current auto-fill. The
                 *   starting cell is coordinate 0 regardless of its physical position
                 *   in the DataTable.
                 * @return {string} Value to write
                 */
                step: function (cell, read, last, i, x, y) {
                    // Increment a number if it is found
                    var re = /(\-?\d+)/;
                    var match = this.increment && last ? last.match(re) : null;
                    if (match) {
                        return last.replace(re, parseInt(match[1], 10) + (x < 0 || y < 0 ? -1 : 1));
                    }
                    return last === undefined ?
                            read :
                            last;
                }
            }
        };

        return AutoFill;
    };


// Define as an AMD module if possible
    if (typeof define === 'function' && define.amd) {
        define(['jquery', 'datatables'], factory);
    } else if (typeof exports === 'object') {
        // Node/CommonJS
        factory(require('jquery'), require('datatables'));
    } else if (jQuery && !jQuery.fn.dataTable.AutoFill) {
        // Otherwise simply initialise as normal, stopping multiple evaluation
        factory(jQuery, jQuery.fn.dataTable);
    }


}(window, document));

